// 实时数据监控系统 - 核心配置文件

const realTimeSystem = {
    // 系统配置
    config: {
        updateFrequency: 1000, // 默认数据更新频率（毫秒）
        maxDataPoints: 100,    // 图表最大数据点数量
        alertThresholds: {
            cpu: 80,           // CPU使用率告警阈值
            memory: 85,        // 内存使用率告警阈值
            latency: 500       // 延迟告警阈值（毫秒）
        },
        notificationSettings: {
            enableSound: true, // 是否启用声音提醒
            enableVisual: true // 是否启用视觉提醒
        }
    },

    // 核心模块
    modules: {},

    // 初始化系统
    init() {
        console.log('实时数据监控系统初始化...');
        
        // 加载本地存储的配置
        this.loadConfig();
        
        // 初始化核心模块
        this.initializeModules();
        
        // 启动系统
        this.start();
        
        console.log('系统初始化完成');
    },

    // 加载配置
    loadConfig() {
        try {
            const savedConfig = localStorage.getItem('realtimeSystemConfig');
            if (savedConfig) {
                const parsedConfig = JSON.parse(savedConfig);
                this.config = { ...this.config, ...parsedConfig };
            }
        } catch (error) {
            console.error('加载配置失败:', error);
        }
    },

    // 保存配置
    saveConfig() {
        try {
            localStorage.setItem('realtimeSystemConfig', JSON.stringify(this.config));
        } catch (error) {
            console.error('保存配置失败:', error);
        }
    },

    // 更新配置
    updateConfig(newConfig) {
        this.config = { ...this.config, ...newConfig };
        this.saveConfig();
        
        // 通知所有模块配置已更新
        Object.values(this.modules).forEach(module => {
            if (module.onConfigUpdate) {
                module.onConfigUpdate(this.config);
            }
        });
    },

    // 初始化模块
    initializeModules() {
        // 这些模块将在后续文件中定义
        this.modules.webSocketClient = null;
        this.modules.dataStream = null;
        this.modules.alertEngine = null;
        this.modules.historyPlayback = null;
        this.modules.multiDashboard = null;
    },

    // 注册模块
    registerModule(name, module) {
        if (this.modules[name]) {
            console.warn(`模块 ${name} 已存在，将被替换`);
        }
        this.modules[name] = module;
        console.log(`模块 ${name} 已注册`);
    },

    // 获取模块
    getModule(name) {
        return this.modules[name] || null;
    },

    // 启动系统
    start() {
        console.log('系统启动中...');
        
        // 显示加载完成
        setTimeout(() => {
            const loadingOverlay = document.getElementById('loading-overlay');
            if (loadingOverlay) {
                loadingOverlay.style.opacity = '0';
                setTimeout(() => {
                    loadingOverlay.style.display = 'none';
                }, 300);
            }
        }, 1000);
    },

    // 停止系统
    stop() {
        console.log('系统停止中...');
        
        // 停止所有模块
        Object.values(this.modules).forEach(module => {
            if (module.stop) {
                module.stop();
            }
        });
    },

    // 获取系统状态
    getStatus() {
        const status = {
            config: this.config,
            modules: {},
            uptime: performance.now()
        };
        
        // 收集各模块状态
        Object.entries(this.modules).forEach(([name, module]) => {
            if (module.getStatus) {
                status.modules[name] = module.getStatus();
            } else {
                status.modules[name] = 'unknown';
            }
        });
        
        return status;
    },

    // 发送系统事件
    emit(event, data) {
        const eventData = {
            type: event,
            data: data,
            timestamp: Date.now()
        };
        
        // 触发自定义事件
        window.dispatchEvent(new CustomEvent(`realtime:${event}`, {
            detail: eventData
        }));
    },

    // 监听系统事件
    on(event, callback) {
        window.addEventListener(`realtime:${event}`, (e) => {
            callback(e.detail.data, e.detail);
        });
    },

    // 工具方法
    utils: {
        // 生成随机数据（用于演示）
        generateRandomData(min, max) {
            return Math.random() * (max - min) + min;
        },

        // 格式化时间戳
        formatTimestamp(timestamp) {
            const date = new Date(timestamp);
            const hours = date.getHours().toString().padStart(2, '0');
            const minutes = date.getMinutes().toString().padStart(2, '0');
            const seconds = date.getSeconds().toString().padStart(2, '0');
            return `${hours}:${minutes}:${seconds}`;
        },

        // 格式化数字（添加千位分隔符）
        formatNumber(num) {
            return num.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
        },

        // 计算数据统计信息
        calculateStats(data) {
            if (!data || data.length === 0) {
                return { min: 0, max: 0, avg: 0, sum: 0 };
            }
            
            const sum = data.reduce((acc, val) => acc + val, 0);
            const min = Math.min(...data);
            const max = Math.max(...data);
            const avg = sum / data.length;
            
            return { min, max, avg, sum };
        },

        // 节流函数
        throttle(func, delay) {
            let lastCall = 0;
            return function(...args) {
                const now = Date.now();
                if (now - lastCall >= delay) {
                    lastCall = now;
                    return func.apply(this, args);
                }
            };
        },

        // 防抖函数
        debounce(func, delay) {
            let timeoutId;
            return function(...args) {
                clearTimeout(timeoutId);
                timeoutId = setTimeout(() => func.apply(this, args), delay);
            };
        },

        // 深拷贝对象
        deepClone(obj) {
            return JSON.parse(JSON.stringify(obj));
        },

        // 检查是否在指定范围内
        isInRange(value, min, max) {
            return value >= min && value <= max;
        },

        // 获取随机颜色
        getRandomColor() {
            const letters = '0123456789ABCDEF';
            let color = '#';
            for (let i = 0; i < 6; i++) {
                color += letters[Math.floor(Math.random() * 16)];
            }
            return color;
        },

        // 添加动画类
        animateElement(element, className, duration = 300) {
            if (!element) return;
            element.classList.add(className);
            setTimeout(() => {
                element.classList.remove(className);
            }, duration);
        }
    }
};

// 导出系统对象
window.realTimeSystem = realTimeSystem;